package modelo;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import clasesAuxiliares.ItemPesoRelativoCriterio;

/**
 * Created by Usuario on 01/11/2014.
 */
public class MatrizComparacionCriterios extends MatrizBase{

    public ArrayList<ItemPesoRelativoCriterio> getPesoRelativoCriterios() {
        return pesoRelativoCriterios;
    }

    public void setPesoRelativoCriterios(ArrayList<ItemPesoRelativoCriterio> pesoRelativoCriterios) {
        this.pesoRelativoCriterios = pesoRelativoCriterios;
    }

    ArrayList<ItemPesoRelativoCriterio> pesoRelativoCriterios;

    public MatrizComparacionCriterios() {
        super();
        this.pesoRelativoCriterios = new ArrayList<ItemPesoRelativoCriterio>();
    }

    public ArrayList<Double> prodMatriz_X_PesosRelativos(){
        ArrayList<Double> pesosRelativos = this.sumarFilasColumnas(true);
        ArrayList<Double> producto = new ArrayList<Double>();

        for (Item c : this.itemsComparados){
            double acu = 0;
            for (Comparacion comp : this.matrizBase){
                int indPesoRelativo = 0;
                if (comp.getPrimerTermino() == c){
                    acu += comp.getPuntaje() * (double)pesosRelativos.get(indPesoRelativo);
                    indPesoRelativo++;
                }
            }
            producto.add(acu);
        }

        return producto;
    }

    public ArrayList<Double> calcularPesosRelativos(){
        ArrayList<Double> divisores = this.sumarFilasColumnas(true);
        ArrayList<Double> pesosRelativos = new ArrayList<Double>();
        pesoRelativoCriterios = new ArrayList<ItemPesoRelativoCriterio>();

        for   (Item c : itemsComparados){
            int indDivisores = 0; // Indice para ir pasando los divisores.
            double pesoRelativo = 0; //Acumulador de peso relativo para almacenar en el array.
            for (Comparacion comp : matrizBase){

                if (comp.getPrimerTermino() == c){
                    pesoRelativo+= comp.getPuntaje()/divisores.get(indDivisores);
                    indDivisores++; //Paso al proximo array de divisores.
                }

            }
            pesoRelativo = pesoRelativo/divisores.size();
            ItemPesoRelativoCriterio itPeso = new ItemPesoRelativoCriterio(c.getNombre(),pesoRelativo);
            pesoRelativoCriterios.add(itPeso);
            pesosRelativos.add(pesoRelativo);

        }

        return pesosRelativos;
    }


    /**
     * Método para sumar todos los valores de una lista.
     * @param resultadoAW
     * @return
     */
    public double sumaAW(ArrayList<Double> resultadoAW){

        double suma = 0; //Acumulador donde se va sumando la lista del producto.

        for (Double d : resultadoAW){ //Recorro la lista.
            suma += d.doubleValue(); //Acumulo.
        }
        return suma;
    }

    public double calcularLambdaMax(){
        ArrayList<Double> pesosRelativos = this.calcularPesosRelativos();
        ArrayList<Double> productoAW = this.prodAW(pesosRelativos);
        double lambdaMax = sumaAW(productoAW);

        return lambdaMax/productoAW.size();
    }

    public Item getItemById(int id){
        for (Item it : itemsComparados){
            if(it.getId()==id){
                return it;
            }
        }
        return null;
    }
}
